import UserSnapshot from './sequelize/UserSnapshot';
import { v4 as uuidv4 } from 'uuid';

export interface UserSnapshotData {
  userId?: string | null;
  userName?: string | null;
  userAvatar?: string | null;
  payGrade?: number | null;
  fansLevel?: number | null;
  fansClubName?: string | null;
  // 管理员权限字段
  isAdmin?: boolean | null;
}

export class UserSnapshotService {
  /**
   * 创建用户快照
   * @param snapshotData 用户快照数据
   * @returns 创建的用户快照ID
   */
  async createUserSnapshot(snapshotData: UserSnapshotData): Promise<string> {
    try {
      const snapshot = await UserSnapshot.create({
        id: uuidv4(),
        ...snapshotData
      });
      return snapshot.id;
    } catch (error) {
      console.error('创建用户快照失败:', error);
      throw error;
    }
  }

  /**
   * 根据ID获取用户快照
   * @param snapshotId 快照ID
   * @returns 用户快照数据
   */
  async getUserSnapshot(snapshotId: string): Promise<UserSnapshot | null> {
    try {
      return await UserSnapshot.findByPk(snapshotId, {
        include: [
          { model: require('./sequelize/User').default, as: 'user' }
        ]
      });
    } catch (error) {
      console.error('获取用户快照失败:', error);
      throw error;
    }
  }

  /**
   * 根据用户ID获取最新的用户快照
   * @param userId 用户ID
   * @returns 最新的用户快照
   */
  async getLatestUserSnapshot(userId: string): Promise<UserSnapshot | null> {
    try {
      return await UserSnapshot.findOne({
        where: { userId },
        order: [['createdAt', 'DESC']]
      });
    } catch (error) {
      console.error('获取最新用户快照失败:', error);
      throw error;
    }
  }

  /**
   * 获取用户的所有快照
   * @param userId 用户ID
   * @param page 页码
   * @param limit 每页数量
   * @returns 用户快照列表和总数
   */
  async getUserSnapshots(
    userId: string, 
    page: number = 1, 
    limit: number = 10
  ): Promise<{ snapshots: UserSnapshot[], total: number }> {
    try {
      const offset = (page - 1) * limit;
      
      const { count, rows } = await UserSnapshot.findAndCountAll({
        where: {
          userId
        },
        order: [['createdAt', 'DESC']],
        offset,
        limit
      });

      return {
        snapshots: rows,
        total: count
      };
    } catch (error) {
      console.error('获取用户快照失败:', error);
      throw error;
    }
  }

  /**
   * 检查是否需要创建新的用户快照
   * 1. 如果用户不存在，则先插入用户表
   * 2. 如果用户数据发生变化，则创建新快照
   * @param userId 用户ID
   * @param currentUserData 当前用户数据
   * @returns 快照ID（新创建或现有的）
   */
  async ensureUserSnapshot(
    userId: string,
    currentUserData: UserSnapshotData,
    gender?: number,
    shortId?: string,
    displayId?: string
  ): Promise<string> {
    try {
      // 1. 确保用户存在于用户表中
      const User = (await import('./sequelize/User')).default;
      const [user, created] = await User.findOrCreate({
        where: { id: userId },
        defaults: {
          id: userId,
          name: currentUserData.userName || '',
          gender: gender || null,
          shortId: shortId || null,
          displayId: displayId || null
        }
      });
      
   
      
      // 2. 获取最新的用户快照
      const latestSnapshot = await this.getLatestUserSnapshot(userId);
      
      // 3. 如果没有快照或用户信息发生变化，创建新快照
      if (!latestSnapshot || this.hasUserDataChanged(latestSnapshot, currentUserData)) {
        const snapshotId = await this.createUserSnapshot({
          userId,
          ...currentUserData
        });
       // console.log(`📸 用户快照已${latestSnapshot ? '更新' : '创建'}: ${userId}`);
        return snapshotId;
      }
      
      // 4. 返回现有快照ID
      return latestSnapshot.id;
    } catch (error) {
      console.error('写入用户快照失败:', error);
      throw error;
    }
  }

  /**
   * 检查用户数据是否发生变化
   * @param snapshot 现有快照
   * @param newData 新数据
   * @returns 是否发生变化
   */
  private hasUserDataChanged(snapshot: UserSnapshot, newData: UserSnapshotData): boolean {
    const fields = ['userName', 'userAvatar', 'payGrade', 'fansLevel', 'fansClubName'];
    
    return fields.some(field => {
      const snapshotValue = (snapshot as any)[field];
      const newValue = (newData as any)[field];
      
      // 特殊处理头像URL：抖音CDN可能使用不同域名但指向同一图片
      if (field === 'userAvatar') {
        return !this.isSameAvatarUrl(snapshotValue, newValue);
      }
      
      return snapshotValue !== newValue;
    });
  }

  /**
   * 智能比较头像URL是否为同一张图片
   * 处理抖音CDN域名变化的情况（如p11.douyinpic.com vs p26.douyinpic.com）
   * @param url1 第一个URL
   * @param url2 第二个URL
   * @returns 是否为同一张图片
   */
  private isSameAvatarUrl(url1: string | null, url2: string | null): boolean {
    // 如果两个URL都为空或null，认为相同
    if (!url1 && !url2) return true;
    
    // 如果只有一个为空，认为不同
    if (!url1 || !url2) return false;
    
    // 如果完全相同，直接返回true
    if (url1 === url2) return true;
    
    try {
      // 解析URL
      const parsedUrl1 = new URL(url1);
      const parsedUrl2 = new URL(url2);
      
      // 检查是否都是抖音CDN域名
      const douyinCdnPattern = /^p\d+\.douyinpic\.com$/;
      const isDouyinCdn1 = douyinCdnPattern.test(parsedUrl1.hostname);
      const isDouyinCdn2 = douyinCdnPattern.test(parsedUrl2.hostname);
      
      if (isDouyinCdn1 && isDouyinCdn2) {
        // 对于抖音CDN，比较路径和查询参数，忽略域名差异
        const path1 = parsedUrl1.pathname + parsedUrl1.search;
        const path2 = parsedUrl2.pathname + parsedUrl2.search;
        return path1 === path2;
      }
      
      // 对于非抖音CDN，进行完整URL比较
      return url1 === url2;
      
    } catch (error) {
      // URL解析失败时，回退到字符串比较
      console.warn('URL解析失败，回退到字符串比较:', error);
      return url1 === url2;
    }
  }
}

export default UserSnapshotService;
